// 创建一个新的工具类来解决类加载器问题

package site.edody.dframe.plugin;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;

/**
 * 类加载器兼容性工具
 */
public class ClassLoaderCompatibilityHelper {
    private static final Logger log = LoggerFactory.getLogger(ClassLoaderCompatibilityHelper.class);

    private final CodeBasedDependencyManager dependencyManager;
    private final Map<String, Class<?>> classCache = new HashMap<>();

    public ClassLoaderCompatibilityHelper(CodeBasedDependencyManager dependencyManager) {
        this.dependencyManager = dependencyManager;
    }

    /**
     * 安全地加载类，处理类加载器兼容性问题
     */
    public Class<?> loadClassSafely(String className) throws ClassNotFoundException {
        // 首先尝试从缓存加载
        if (classCache.containsKey(className)) {
            return classCache.get(className);
        }

        // 使用依赖管理器加载
        Class<?> clazz = dependencyManager.loadClass(className);
        classCache.put(className, clazz);
        return clazz;
    }

    /**
     * 检查两个类是否兼容（处理跨类加载器情况）
     */
    public boolean isClassCompatible(Class<?> class1, Class<?> class2) {
        if (class1 == class2) {
            return true;
        }

        // 检查类名
        if (!class1.getName().equals(class2.getName())) {
            return false;
        }

        // 类名相同，即使类加载器不同也认为是兼容的
        log.debug("类名相同但类加载器不同 - 认为兼容: {} (loader1: {}, loader2: {})",
                class1.getName(),
                class1.getClassLoader(),
                class2.getClassLoader());
        return true;
    }

    /**
     * 安全调用方法，处理参数类型兼容性
     */
    public Object invokeMethodSafely(Object target, String methodName, Object[] params) throws Exception {
        Class<?> targetClass = target.getClass();
        Method[] methods = targetClass.getMethods();

        for (Method method : methods) {
            if (method.getName().equals(methodName) && method.getParameterCount() == params.length) {
                // 检查参数兼容性
                boolean compatible = true;
                Class<?>[] paramTypes = method.getParameterTypes();

                for (int i = 0; i < paramTypes.length; i++) {
                    if (params[i] != null && !isParameterCompatible(paramTypes[i], params[i].getClass())) {
                        compatible = false;
                        break;
                    }
                }

                if (compatible) {
                    return method.invoke(target, params);
                }
            }
        }

        throw new NoSuchMethodException("未找到兼容的方法: " + methodName);
    }

    /**
     * 检查参数兼容性
     */
    protected boolean isParameterCompatible(Class<?> expected, Class<?> actual) {
        // 使用类名比较来处理跨类加载器情况
        if (expected.getName().equals(actual.getName())) {
            return true;
        }

        // 检查继承关系
        Class<?> current = actual;
        while (current != null) {
            if (current.getName().equals(expected.getName())) {
                return true;
            }
            current = current.getSuperclass();
        }

        // 检查接口实现
        for (Class<?> iface : actual.getInterfaces()) {
            if (iface.getName().equals(expected.getName())) {
                return true;
            }
        }

        return false;
    }
}